fix(source-chat): emit SSE keepalives during generation and add stop-… - #1332

…streaming button

Keep the source chat SSE connection alive while the LLM generates by sending
ignored  comments every 15 seconds, preventing proxies (including the
Next.js rewrite in front of FastAPI) from dropping the idle connection.

On the frontend, wire up an AbortController so users can stop an in-flight
stream with a new stop button, abort previous requests when sending a new
message, and abort on unmount. Add  translations for all supported
locales and a characterization test for the keepalive behavior.

… superseded streams

Check the checkpoint state before persisting the user message in
; skip the up-front append when the same human
message is already the unanswered trailing turn, preventing duplicates on
retry after a failed generation.

In the frontend, guard the streaming cleanup so a superseded send (a newer
message replaced the in-flight one) does not clear the newer stream's
loading state or trigger a stale refetch. Also show a disabled spinner in
the chat composer when streaming has no cancel callback (e.g. notebook
chat) instead of a non-functional Stop button.

Update characterization tests: make the keepalive test deterministic with
an , and add tests for the duplicate-pending-message skip
and normal append-after-AI-message behavior.

…-session streams

Add a client-generated  to  and use it (instead of content equality) to skip the up-front user-message append on retry, while still keeping distinct identical messages. Serialize the snapshot → append → invoke sequence per session with an  so concurrent requests for the same thread cannot start duplicate generations.

Update the frontend to reuse the trailing unanswered human message id when retrying the same content and generate a fresh uuid otherwise, and to clear streaming state when session creation fails. Add ADR-009 documenting the  async-to-sync bridge. Add/update characterization and hook tests for message-id dedup, distinct identical messages, and streaming lifecycle.

The test fixture set `model_override: null`, violating
`SourceChatSession.model_override?: string` (the interface narrows the
base type's `string | null`). And `sendPromise` was read before
TypeScript could prove it assigned (assigned only inside an `act()`
callback), triggering TS2454. Drop the invalid field and use a
definite-assignment assertion.

Co-authored-by: Cursor <cursoragent@cursor.com>

…sage ids

- Replace the global per-session `asyncio.Lock` dict with a refcounted `_SessionLock` that evicts its entry once the last stream releases, preventing an unbounded lock table in a long-lived process.
- Add characterization test verifying the lock entry is removed after the stream finishes.
- Extract `selectMessageId()` to decide whether to reuse the trailing unanswered human id (retry) or generate a fresh uuid (new turn), and send that real id optimistically so the backend `already_pending` check matches the optimistic entry.
- Stop filtering `temp-*` ids on send error since optimistic messages now carry their real ids.
- Update ADR-009 to include `aget_tuple` in the async-to-sync delegation surface.

…d lock waits

- Add a 1s disconnect poll interval separate from the 15s SSE keepalive so dropped connections stop generation promptly; only emit  keepalives when due.
- Track whether the session lock was actually acquired and, if the stream is cancelled while waiting, decrement the holder count without releasing an unheld lock.
- Serialize concurrent first-time sends into a single session-create promise, avoid duplicate optimistic bubbles on retry, and roll back the optimistic user message if send fails before persistence.
- Use a  label for the non-cancellable notebook-chat spinner and add translations for all locales.
- Update characterization and hook tests for the new poll interval, lock cancellation, and send races.

…bles on failure, and support non-secure UUID generation

- When a user cancels streaming while an auto-create session request is still in flight, adopt the created session id once it resolves and invalidate the sessions list so the next send does not create another empty session.
- On send failure, only roll back an optimistic user message added in the current turn; a retry that reuses a persisted trailing human id keeps its bubble visible until the refetch completes.
- Add `createMessageId()` with a `Math.random` fallback for contexts where `crypto.randomUUID` is unavailable (e.g. non-secure HTTP) and use it as the default id generator.
- Update tests for the new stop-during-create behavior, retry-failure visibility, and UUID fallback; rename the notebook-chat composer test to clarify "without stop support".

…tend stale-state races

- Move the per-session lock and pending human-turn persistence policy from `api/routers/source_chat.py` into a new `api/source_chat_service.py` module, exposing `source_chat_turn` so the router delegates serialization and persistence.
- Add focused unit tests for the refcounted session lock (serialization, eviction, and cancelled-waiter cleanup) and the message-id-based pending-turn deduplication; update characterization tests to import from the new module.
- In the frontend `useSourceChat` hook, use refs and a per-send generation token so stale session snapshots cannot overwrite messages from a newer stream, resolve authoritative state before choosing the message id, and skip session adoption when the abort comes from unmount rather than Stop.
- Add tests for authoritative state resolution, stale-refetch suppression, and unmount abort behavior.

…ssages across session switches

- Add `getLogSafeErrorMessage()` to strip `Authorization` headers and bound error length before `console.error`, so axios request configs carrying bearer tokens are never logged.
- Use the new helper in `useSourceChat` for session creation, hydration, and send failures.
- Track which session the shared `messages` list represents via `messagesSessionRef`; only apply stream chunks and optimistic turns when the list still belongs to the originating session, and re-attach the full accumulated answer when the user switches back.
- Add tests verifying auth tokens are absent from logs, sends stay on their original session during pre-send hydration switches, and streaming sessions rehydrate correctly after switching away and back.

  before claiming the shared list and restore console spy
  safely

…superseded stream handling

- Add `SessionTurnLease` in `api/source_chat_service.py` to acquire the per-session turn lock by polling instead of blocking, so SSE streams can emit keepalive comments and detect client disconnects while queued behind another turn.
- Update `stream_source_chat_response` to poll the lease, emit due keepalives before the final response, and release the lease cleanly on cancellation.
- Fail sends in `useSourceChat` when pre-send session hydration errors, rather than minting an unverified message id that would bypass backend dedup.
- Ensure only the latest send writes shared state: guard `context_indicators` and message ownership against superseded streams, and refetch the persisted checkpoint after cancellation so the pending turn survives.
- Add characterization tests for queued keepalives, queued disconnect cleanup, and due keepalive before completion; update hook tests for cancellation unwind, retry id reuse, and hydration failure.

Co-authored-by: cubic-dev-ai[bot] <191113872+cubic-dev-ai[bot]@users.noreply.github.com>

…nd hydration

The session-created guard left `else if (!sessionJustCreated)` dead after
the explicit fresh-session branch was added; fold it into a plain `else`.

Co-Authored-By: Claude <noreply@anthropic.com>